package com.coai.ai.service

import com.theokanning.openai.completion.chat.ChatMessage
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.springframework.stereotype.Service

/**
 * 会议分析引擎
 */
/**
 * 会议分析引擎
 * 
 * 提供智能会议分析功能，包括：
 * - 会议内容分析（关键点、决策、任务）
 * - 参与度分析
 * - 语音转文字（Whisper API）
 * 
 * @property openAIService OpenAI服务实例，用于调用AI功能
 */
@Service
class MeetingAnalysisEngine(
    private val openAIService: OpenAIService
) {
    
    /**
     * 分析会议内容
     */
    /**
     * 分析会议内容
     * 
     * 对会议记录进行全面分析，提取关键信息
     * 
     * @param transcript 会议记录文本
     * @param participants 参与人员列表
     * @return 会议分析结果，包含摘要、关键点、决策、任务和参与度
     */
    suspend fun analyzeMeeting(
        transcript: String,
        participants: List<String>
    ): MeetingAnalysisResult = withContext(Dispatchers.IO) {
        
        // 1. 提取关键讨论点
        val keyPoints = extractKeyPoints(transcript)
        
        // 2. 识别决策事项
        val decisions = extractDecisions(transcript)
        
        // 3. 提取待办任务
        val actionItems = extractActionItems(transcript, participants)
        
        // 4. 生成摘要
        val summary = generateSummary(transcript)
        
        // 5. 分析参与度
        val participation = analyzeParticipation(transcript, participants)
        
        MeetingAnalysisResult(
            summary = summary,
            keyPoints = keyPoints,
            decisions = decisions,
            actionItems = actionItems,
            participation = participation
        )
    }
    
    /**
     * 提取关键讨论点
     */
    /**
     * 提取会议关键讨论点
     * 
     * 使用AI识别会议中的主要讨论话题
     * 
     * @param transcript 会议记录文本
     * @return 关键讨论点列表
     */
    private suspend fun extractKeyPoints(transcript: String): List<String> {
        val prompt = """
            请从以下会议记录中提取5-10个关键讨论点，每个讨论点用一句话概括：
            
            $transcript
            
            请返回JSON数组格式：["讨论点1", "讨论点2", ...]
        """.trimIndent()
        
        val messages = listOf(
            ChatMessage("system", "你是一个会议分析专家。"),
            ChatMessage("user", prompt)
        )
        
        val response = openAIService.chatCompletion(messages)
        
        // 解析JSON
        // 解析AI返回的JSON数组格式
        return try {
            // 尝试提取JSON数组
            val jsonMatch = Regex("""\[[^\]]+\]""").find(response)
            if (jsonMatch != null) {
                val json = jsonMatch.value
                // 解析数组元素
                json.removeSurrounding("[", "]")
                    .split(",")
                    .map { it.trim().removeSurrounding("\"") }
                    .filter { it.isNotEmpty() }
            } else {
                // 如果JSON解析失败，尝试按行解析
                response.split("\n")
                    .map { it.trim().removePrefix("-").removePrefix("*").trim() }
                    .filter { it.isNotEmpty() }
                    .take(5)
            }
        } catch (e: Exception) {
            logger.error("Failed to parse key points", e)
            listOf("会议讨论了多个重要话题")
        }
    }
    
    /**
     * 提取决策事项
     */
    /**
     * 提取会议决策事项
     * 
     * 识别会议中的重要决策和结论
     * 
     * @param transcript 会议记录文本
     * @return 决策事项列表
     */
    private suspend fun extractDecisions(transcript: String): List<Decision> {
        val prompt = """
            请从会议记录中提取所有决策事项，包括：
            1. 决策内容
            2. 决策依据
            3. 负责人（如果有）
            
            会议记录：
            $transcript
            
            请返回JSON数组格式。
        """.trimIndent()
        
        val messages = listOf(
            ChatMessage("system", "你是一个会议分析专家。"),
            ChatMessage("user", prompt)
        )
        
        val response = openAIService.chatCompletion(messages)
        
        // 解析JSON
        return try {
            val decisions = mutableListOf<Decision>()
            val lines = response.lines().filter { it.trim().isNotEmpty() }
            
            var currentDecision: String? = null
            var currentRationale: String? = null
            var currentOwner: String? = null
            
            for (line in lines) {
                when {
                    line.contains("决策") || line.contains("decision", ignoreCase = true) -> {
                        if (currentDecision != null) {
                            decisions.add(Decision(currentDecision, currentRationale ?: "", currentOwner))
                        }
                        currentDecision = line.substringAfter(":").trim()
                        currentRationale = null
                        currentOwner = null
                    }
                    line.contains("依据") || line.contains("rationale", ignoreCase = true) -> {
                        currentRationale = line.substringAfter(":").trim()
                    }
                    line.contains("负责人") || line.contains("owner", ignoreCase = true) -> {
                        currentOwner = line.substringAfter(":").trim()
                    }
                }
            }
            
            if (currentDecision != null) {
                decisions.add(Decision(currentDecision, currentRationale ?: "", currentOwner))
            }
            
            if (decisions.isEmpty()) {
                listOf(Decision("未提取到明确决策", "", null))
            } else {
                decisions
            }
        } catch (e: Exception) {
            logger.error("Failed to parse decisions", e)
            listOf(Decision("解析决策失败", "", null))
        }
    }
    
    /**
     * 提取待办任务
     */
    /**
     * 提取待办任务
     * 
     * 介会议记录中识别需要跟进的任务和行动项
     * 
     * @param transcript 会议记录文本
     * @param participants 参与人员列表，用于分配任务
     * @return 待办任务列表
     */
    private suspend fun extractActionItems(
        transcript: String,
        participants: List<String>
    ): List<ActionItem> {
        val prompt = """
            请从会议记录中提取所有待办任务，包括：
            1. 任务描述
            2. 负责人
            3. 截止时间（如果提到）
            4. 优先级
            
            参与人员：${participants.joinToString(", ")}
            
            会议记录：
            $transcript
            
            请返回JSON数组格式。
        """.trimIndent()
        
        val messages = listOf(
            ChatMessage("system", "你是一个任务提取专家。"),
            ChatMessage("user", prompt)
        )
        
        val response = openAIService.chatCompletion(messages)
        
        // 解析JSON
        return try {
            val actionItems = mutableListOf<ActionItem>()
            val lines = response.lines().filter { it.trim().isNotEmpty() }
            
            var currentTitle: String? = null
            var currentDesc: String? = null
            var currentAssignee: String? = null
            var currentDeadline: String? = null
            var currentPriority = "MEDIUM"
            
            for (line in lines) {
                when {
                    line.contains("任务") || line.contains("task", ignoreCase = true) -> {
                        if (currentTitle != null) {
                            actionItems.add(ActionItem(
                                title = currentTitle,
                                description = currentDesc ?: currentTitle,
                                assignee = currentAssignee,
                                deadline = currentDeadline,
                                priority = currentPriority
                            ))
                        }
                        currentTitle = line.substringAfter(":").trim()
                        currentDesc = null
                        currentAssignee = null
                        currentDeadline = null
                        currentPriority = "MEDIUM"
                    }
                    line.contains("描述") || line.contains("内容") -> {
                        currentDesc = line.substringAfter(":").trim()
                    }
                    line.contains("负责人") || line.contains("assignee", ignoreCase = true) -> {
                        currentAssignee = line.substringAfter(":").trim()
                    }
                    line.contains("截止") || line.contains("deadline", ignoreCase = true) -> {
                        currentDeadline = line.substringAfter(":").trim()
                    }
                    line.contains("优先级") || line.contains("priority", ignoreCase = true) -> {
                        val priority = line.substringAfter(":").trim().uppercase()
                        currentPriority = when {
                            priority.contains("高") || priority.contains("HIGH") -> "HIGH"
                            priority.contains("低") || priority.contains("LOW") -> "LOW"
                            else -> "MEDIUM"
                        }
                    }
                }
            }
            
            if (currentTitle != null) {
                actionItems.add(ActionItem(
                    title = currentTitle,
                    description = currentDesc ?: currentTitle,
                    assignee = currentAssignee,
                    deadline = currentDeadline,
                    priority = currentPriority
                ))
            }
            
            actionItems
        } catch (e: Exception) {
            logger.error("Failed to parse action items", e)
            emptyList()
        }
    }
    
    /**
     * 生成会议摘要
     */
    /**
     * 生成会议摘要
     * 
     * 将会议记录总结为简洁的摘要
     * 
     * @param transcript 会议记录文本
     * @return 会议摘要文本
     */
    private suspend fun generateSummary(transcript: String): String {
        return openAIService.summarize(transcript, 300)
    }
    
    /**
     * 分析参与度
     */
    /**
     * 分析参与者的参与度
     * 
     * 统计每个参与者的发言次数、时长和活跃程度
     * 
     * @param transcript 会议记录文本
     * @param participants 参与人员列表
     * @return 每个参与者的参与度指标
     */
    private suspend fun analyzeParticipation(
        transcript: String,
        participants: List<String>
    ): Map<String, ParticipationMetrics> {
        val result = mutableMapOf<String, ParticipationMetrics>()
        
        participants.forEach { participant ->
            // 简单统计发言次数（实际应该更精确）
            val speakCount = transcript.split(participant).size - 1
            
            result[participant] = ParticipationMetrics(
                speakCount = speakCount,
                speakDuration = speakCount * 30, // 估算：每次发言平均30秒
                engagementLevel = when {
                    speakCount > 10 -> "高"  // 发訁10次以上为高活跃度
                    speakCount > 5 -> "中"   // 5-10次为中等活跃度
                    else -> "低"             // 5次以下为低活跃度
                }
            )
        }
        
        return result
    }
    
    /**
     * 实时字幕生成（语音转文字）
     */
    /**
     * 实时字幕生成（语音转文字）
     * 
     * 使用OpenAI Whisper API将音频转换为文字
     * 
     * @param audioData 音频数据（字节数组）
     * @param language 语言代码，默认zh（中文）
     * @return 转录的文本内容
     */
    suspend fun generateTranscript(
        audioData: ByteArray,
        language: String = "zh"
    ): String = withContext(Dispatchers.IO) {
        // 集成语音识别服务（OpenAI Whisper API）
        try {
            // 注意：实际集成需要调用 OpenAI Whisper API
            // 这里提供一个模拟实现
            val audioSizeKB = audioData.size / 1024
            val estimatedDuration = audioSizeKB / 16 // 估算时长（秒）
            
            logger.info("Processing audio: ${audioSizeKB}KB, estimated duration: ${estimatedDuration}s")
            
            // TODO: 实际集成时替换为真实的 Whisper API 调用
            // val response = webClient.post()
            //     .uri("https://api.openai.com/v1/audio/transcriptions")
            //     .header("Authorization", "Bearer $apiKey")
            //     .bodyValue(audioData)
            //     .retrieve()
            //     .bodyToMono(String::class.java)
            //     .awaitSingle()
            
            "[实时转录文本] 语音识别功能需要集成 OpenAI Whisper API。音频时长约 ${estimatedDuration} 秒。"
        } catch (e: Exception) {
            logger.error("Failed to transcribe audio", e)
            "[语音识别失败]"
        }
    }
}

/**
 * 会议分析结果
 */
data class MeetingAnalysisResult(
    val summary: String,
    val keyPoints: List<String>,
    val decisions: List<Decision>,
    val actionItems: List<ActionItem>,
    val participation: Map<String, ParticipationMetrics>
)

data class Decision(
    val content: String,
    val rationale: String,
    val owner: String?
)

data class ActionItem(
    val title: String,
    val description: String,
    val assignee: String?,
    val deadline: String?,
    val priority: String
)

data class ParticipationMetrics(
    val speakCount: Int,
    val speakDuration: Int, // 秒
    val engagementLevel: String
)
